package com.ruoyi.test.service.impl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

import com.ruoyi.common.utils.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.test.mapper.MhTestQuestionMapper;
import com.ruoyi.test.domain.MhTestQuestion;
import com.ruoyi.test.service.IMhTestQuestionService;

/**
 * 测试问题库Service业务层处理
 * 
 * @author ruoyi
 * @date 2025-11-23
 */
@Service
public class MhTestQuestionServiceImpl implements IMhTestQuestionService 
{
    @Autowired
    private MhTestQuestionMapper mhTestQuestionMapper;

    /**
     * 查询测试问题库
     * 
     * @param id 测试问题库主键
     * @return 测试问题库
     */
    @Override
    public MhTestQuestion selectMhTestQuestionById(Long id)
    {
        return mhTestQuestionMapper.selectMhTestQuestionById(id);
    }

    /**
     * 查询测试问题库列表
     * 
     * @param mhTestQuestion 测试问题库
     * @return 测试问题库
     */
    @Override
    public List<MhTestQuestion> selectMhTestQuestionList(MhTestQuestion mhTestQuestion)
    {
        return mhTestQuestionMapper.selectMhTestQuestionList(mhTestQuestion);
    }

    /**
     * 新增测试问题库
     * 
     * @param mhTestQuestion 测试问题库
     * @return 结果
     */
    @Override
    public int insertMhTestQuestion(MhTestQuestion mhTestQuestion)
    {
        mhTestQuestion.setCreateTime(DateUtils.getNowDate());
        return mhTestQuestionMapper.insertMhTestQuestion(mhTestQuestion);
    }

    /**
     * 修改测试问题库
     * 
     * @param mhTestQuestion 测试问题库
     * @return 结果
     */
    @Override
    public int updateMhTestQuestion(MhTestQuestion mhTestQuestion)
    {
        mhTestQuestion.setUpdateTime(DateUtils.getNowDate());
        return mhTestQuestionMapper.updateMhTestQuestion(mhTestQuestion);
    }

    /**
     * 批量删除测试问题库
     * 
     * @param ids 需要删除的测试问题库主键
     * @return 结果
     */
    @Override
    public int deleteMhTestQuestionByIds(Long[] ids)
    {
        return mhTestQuestionMapper.deleteMhTestQuestionByIds(ids);
    }

    /**
     * 删除测试问题库信息
     * 
     * @param id 测试问题库主键
     * @return 结果
     */
    @Override
    public int deleteMhTestQuestionById(Long id)
    {
        return mhTestQuestionMapper.deleteMhTestQuestionById(id);
    }
    
    /**
     * 根据指定题目数获取均分的随机题目列表
     * 
     * @param questionCount 题目数（20、48、96、169、200）
     * @return 测试问题库集合
     */
    @Override
    public List<MhTestQuestion> selectRandomQuestionsByDimension(int questionCount) {
        // 验证题目数是否有效
        List<Integer> validCounts = Arrays.asList(20, 48, 96, 169, 200);
        if (!validCounts.contains(questionCount)) {
            return new ArrayList<>(); // 返回空列表如果题目数无效
        }
        
        // 定义4个维度
        List<String> dimensions = Arrays.asList("E/I", "S/N", "T/F", "J/P");
        
        // 计算每个维度的题目数
        int questionsPerDimension = questionCount / dimensions.size();
        
        // 存储最终结果
        List<MhTestQuestion> result = new ArrayList<>();
        
        // 为每个维度获取随机题目
        for (String dimension : dimensions) {
            // 创建查询条件
            MhTestQuestion query = new MhTestQuestion();
            query.setDimension(dimension);
            
            // 获取该维度的所有题目
            List<MhTestQuestion> allQuestions = mhTestQuestionMapper.selectMhTestQuestionList(query);
            
            // 如果该维度题目不足，跳过
            if (allQuestions.isEmpty()) {
                continue;
            }
            
            // 随机打乱题目顺序
            Collections.shuffle(allQuestions);
            
            // 取出指定数量的题目（如果题目总数少于需要的数量，则取全部）
            int takeCount = Math.min(questionsPerDimension, allQuestions.size());
            List<MhTestQuestion> selectedQuestions = new ArrayList<>(allQuestions.subList(0, takeCount));
            
            // 添加到结果列表
            result.addAll(selectedQuestions);
        }
        
        // 如果结果数量不足（可能某些维度题目不足），从所有题目中随机补充
        if (result.size() < questionCount) {
            // 获取所有题目
            List<MhTestQuestion> allQuestions = mhTestQuestionMapper.selectMhTestQuestionList(new MhTestQuestion());
            
            // 随机打乱
            Collections.shuffle(allQuestions);
            
            // 补充题目直到达到指定数量（避免重复）
            List<Long> existingIds = result.stream().map(MhTestQuestion::getId).collect(Collectors.toList());
            for (MhTestQuestion question : allQuestions) {
                if (result.size() >= questionCount) {
                    break;
                }
                if (!existingIds.contains(question.getId())) {
                    result.add(question);
                    existingIds.add(question.getId());
                }
            }
        }
        
        // 最后再次随机打乱结果
        Collections.shuffle(result);
        
        return result;
    }
}